//! 基于抽象接口的协议处理器（重新设计版本）
//! 
//! 核心设计原则：
//! 1. 协议层直接接收NetworkStream并内部循环处理
//! 2. 完全依赖core模块的抽象trait
//! 3. 协议层不知道具体网络实现（Tokio/QUIC/TLS）
//! 4. 轻量级设计，内存占用控制在几KB

// use std::collections::VecDeque; // 暂时未使用
use crate::core::network::{AsyncNetworkStream, LightweightRuntime};
use crate::core::error::{CoreError, Result as CoreResult};
use crate::protocol::RespParser;
use crate::storage::{Command, GlobalStorageManager, ProtocolErrorResponseCommand};
use crate::event::ConnectionId;
// use std::io; // 暂时未使用

/// 连接状态
#[derive(Debug, Clone)]
pub enum ConnectionState {
    /// 活跃状态
    Active,
    /// 关闭状态
    Closed,
    /// 错误状态
    Error(String),
}

/// 基于抽象接口的协议处理器
/// 
/// 核心特性：
/// 1. 直接接收NetworkStream trait对象并内部循环处理
/// 2. 完全依赖抽象trait，不知道具体实现
/// 3. 轻量级设计，内存占用几KB
/// 4. 支持任意运行时（Tokio/async-std/线程池）
#[derive(Debug)]
pub struct AbstractedProtocolHandler<R: LightweightRuntime> {
    /// 连接ID
    connection_id: ConnectionId,
    /// 轻量级运行时（抽象接口）
    runtime: R,
    /// RESP协议解析器
    resp_parser: RespParser,
    /// 连接状态
    state: ConnectionState,
}

impl<R: LightweightRuntime> AbstractedProtocolHandler<R> {
    /// 创建新的抽象协议处理器
    /// 
    /// 参数：
    /// - connection_id: 连接标识
    /// - runtime: 实现了LightweightRuntime trait的具体运行时
    pub fn new(
        connection_id: ConnectionId,
        runtime: R,
    ) -> Self {
        // 创建抽象协议处理器
        
        Self {
            connection_id,
            runtime,
            resp_parser: RespParser::new(),
            state: ConnectionState::Active,
        }
    }

    /// 协议层主处理函数 - 直接接收NetworkStream并内部循环处理
    /// 
    /// 这是协议层的真正入口函数：
    /// 1. 接收NetworkStream trait对象（具体实现在网络层）
    /// 2. 在协议层内部循环读取数据
    /// 3. 增量解析RESP协议
    /// 4. 执行命令并通过NetworkStream写回响应
    /// 5. 使用异步I/O提供更好的性能
    /// 6. **关键修复**：使用全局共享存储而不是每个连接一个存储
    pub async fn handle_connection_stream(
        &mut self,
        mut stream: Box<dyn AsyncNetworkStream>,
    ) -> CoreResult<()> {
        // 协议层开始处理连接
        
        let mut buffer = vec![0u8; 8192];
        let mut should_stop_reading = false;  // 标记是否应该停止读取数据
        
        // 协议层内部循环 - 持续读取和解析
        while stream.is_connected() && !should_stop_reading {
            // 1. 从NetworkStream异步读取数据
            match stream.read(&mut buffer).await {
                Ok(0) => {
                    // 连接已正常关闭（EOF）
                    // 连接正常关闭，退出循环但不返回错误
                    break;
                }
                Ok(n) => {
                    let data = &buffer[..n];
                    // 收到数据
                    
                    // 2. 增量解析RESP协议
                    self.resp_parser.feed_data(data);
                    
                    // 3. 解析所有完整的命令
                    while let Ok(Some(resp_value)) = self.resp_parser.parse_value() {
                        match self.resp_parser.resp_to_command(resp_value) {
                            Ok(command) => {
                                // 4. 立即执行命令并发送响应（使用全局存储）
                                match self.execute_command_immediately(command) {
                                    Ok(response) => {
                                        // 发送响应
                                        if let Err(e) = stream.write(&response).await {
                                            // 写入响应失败
                                            return Err(CoreError::Network { source: e });
                                        }
                                        
                                        if let Err(e) = stream.flush().await {
                                            // flush失败
                                            return Err(CoreError::Network { source: e });
                                        }
                                    }
                                    Err(e) => {
                                        // 执行命令失败，返回错误给调用者
                                        return Err(e);
                                    }
                                }
                            }
                            Err(e) => {
                                // 协议解析错误 - 创建特殊的错误响应命令发送到核心层
                                // 命令解析失败
                                
                                // 创建特殊的协议错误响应命令
                                let _error_command = Box::new(ProtocolErrorResponseCommand::new(
                                    format!("Protocol error: {e:?}"),
                                    self.connection_id
                                ));
                                
                                // 直接返回错误响应（简化处理）
                                let error_response = "-ERR Protocol parsing error\r\n".as_bytes();
                                if let Err(_) = stream.write(error_response).await {
                                    return Err(CoreError::Protocol { 
                                        message: format!("Protocol parsing failed and cannot send error response: {e:?}") 
                                    });
                                }
                                should_stop_reading = true;
                                break;  // 退出内部命令解析循环
                            }
                        }
                    }
                }
                Err(e) => {
                    // 网络错误 - 直接返回给网络层处理
                    // 读取失败
                    return Err(CoreError::Network { source: e });
                }
            }
        }
        
        // 协议处理完成
        Ok(())
    }

    /// 执行单个命令（使用全局单线程Redis服务器）
    fn execute_command_immediately(
        &self,
        command: Box<dyn Command>,
    ) -> CoreResult<Vec<u8>> {
        let command_name = command.name().to_string();
        let args = command.to_args();
        
        // 🚀 使用全局单线程Redis服务器执行命令（零锁）
        let result = GlobalStorageManager::execute_command(command_name, args)
            .map_err(|e| CoreError::Storage { message: e })?;
        
        let response_data = result.to_resp().into_bytes();
        Ok(response_data)
    }

    // 🗑️ 已删除：execute_redis_command_on_storage 方法
    // 现在所有命令都通过 GlobalStorageManager::execute_command 执行
    // 在单线程Redis服务器中处理，完全避免锁竞争

    /// 关闭连接处理器
    pub fn close(&mut self) -> CoreResult<()> {
        self.state = ConnectionState::Closed;
        // 抽象协议处理器已关闭
        Ok(())
    }

    /// 获取连接ID
    pub fn connection_id(&self) -> ConnectionId {
        self.connection_id
    }

    /// 获取连接状态
    pub fn state(&self) -> &ConnectionState {
        &self.state
    }

    /// 获取内存使用统计（调试用）
    pub fn memory_usage(&self) -> usize {
        std::mem::size_of::<Self>() + 
        1024 // 解析器缓冲区
    }

    /// 获取运行时类型
    pub fn runtime_type(&self) -> &'static str {
        self.runtime.lightweight_type()
    }
}

impl<R: LightweightRuntime> Drop for AbstractedProtocolHandler<R> {
    fn drop(&mut self) {
        let _ = self.close();
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::network::ThreadPoolRuntime;
    
    #[test]
    fn test_abstracted_handler_creation() {
        let runtime = ThreadPoolRuntime::new();
        let handler = AbstractedProtocolHandler::new(1, runtime);
        
        assert_eq!(handler.connection_id(), 1);
        assert!(matches!(handler.state(), ConnectionState::Active));
        assert_eq!(handler.runtime_type(), "ThreadPool");
        
        let memory_kb = handler.memory_usage() / 1024;
        // 内存使用统计
        
        // 验证轻量级设计
        assert!(memory_kb < 100, "内存使用过大: {memory_kb}KB");
    }
}